home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d18 / stackary.arc / STACKTST.PAS < prev   
Pascal/Delphi Source File  |  1991-01-29  |  7KB  |  233 lines
  1. (*
  2.  
  3.     Stack Array library testing program.
  4.  
  5.     by: Ilya Shlyakhter
  6. *)
  7.  
  8.  
  9. PROGRAM TestStackArray (Input,Output);
  10.  
  11.    USES StackAry, RandLib;
  12.  
  13.    PROCEDURE GreetTheUser;
  14.  
  15.       BEGIN  (* GreetTheUser *)
  16.          WriteLn;
  17.          Write ('       *** STARTING THE TEST ***');
  18.          WriteLn;
  19.      WriteLn
  20.       END;   (* GreetTheUser *)
  21.  
  22.    PROCEDURE RandomStackData (VAR Data: StackDataType);
  23.  
  24.    (*
  25.       NOTE: I've tried to make this library as portable and generic as possible.
  26.       However, the way you generate random data heavily depends on the type of
  27.       data.  Therefore, if the data type used in this program is modified, this
  28.       procedure and the next one also have to be modified.
  29.    *)
  30.  
  31.       VAR R: Real;
  32.  
  33.       BEGIN  (* RandomStackData *)
  34.          R := RandomGarlandReal;
  35.  
  36.          IF R >= 0.5 THEN
  37.             Data := Chr (RandomGarlandInt (Ord ('A'), Ord ('Z')))  (* capital letter *)
  38.                ELSE
  39.                   Data := Chr (RandomGarlandInt (Ord ('a'), Ord ('z')))  (* small letter *)
  40.       END;   (* RandomStackData *)
  41.  
  42.  
  43.    PROCEDURE DisplayData (TheData: StackDataType);
  44.  
  45.    (*
  46.       NOTE: See comment for the previous procedure.
  47.    *)
  48.  
  49.       BEGIN  (* DisplayData *)
  50.          Write (TheData)
  51.       END;   (* DisplayData *)
  52.  
  53.    PROCEDURE TestHello;
  54.  
  55.       VAR Stack: StackType;
  56.           Ch: StackDataType;
  57.           Error: Boolean;
  58.  
  59.       BEGIN  (* TestHello *)
  60.          InitStack (Stack);
  61.  
  62.          WriteLn ('Pushing the word HELLO onto the stack:');
  63.  
  64.          Push (Stack,'H',Error);
  65.          Push (Stack,'E',Error);
  66.          Push (Stack,'L',Error);
  67.          Push (Stack,'L',Error);
  68.          Push (Stack,'O',Error);
  69.  
  70.          WriteLn;
  71.          WriteLn ('The stack now contains ',GetStackSize (Stack),' elements.');
  72.          Peek (Stack,Ch,Error);
  73.          Write ('The element at the top is ');
  74.          DisplayData (Ch);
  75.          WriteLn;
  76.  
  77.          WriteLn ('The stack now contains the following elements: ');
  78.          WriteLn;
  79.  
  80.          Pop (Stack,Ch,Error);
  81.          WHILE NOT Error DO
  82.             BEGIN  (* write out the elements of the stack *)
  83.                DisplayData (Ch);
  84.                Pop (Stack,Ch,Error);
  85.             END;   (* write out the elements of the stack *)
  86.  
  87.          WriteLn;
  88.          WriteLn ('    --- End of Hello Test ---');
  89.          WriteLn
  90.       END;   (* TestHello *)
  91.  
  92.    PROCEDURE TestNumbers;
  93.  
  94.       CONST CharsPerLine = 25;
  95.  
  96.       VAR I: StackIndexType;
  97.           TestStack: StackType;
  98.           Ch: StackDataType;
  99.           Error: Boolean;
  100.           OutCount: Integer;  (* number of character output on the line *)
  101.  
  102.       BEGIN  (* TestNumbers *)
  103.          InitGarland (ClockSeedInt);
  104.          InitStack (TestStack);
  105.  
  106.          WriteLn;
  107.          WriteLn;
  108.          WriteLn ('Pushing the following data elements onto the stack:');
  109.          WriteLn;
  110.  
  111.          OutCount := 1;
  112.  
  113.          FOR I := 1 TO MaxStackSize DO
  114.             BEGIN  (* push a random element on the stack *)
  115.                RandomStackData (Ch);
  116.                DisplayData (Ch);
  117.                Push (TestStack, Ch, Error);
  118.  
  119.                IF OutCount = CharsPerLine THEN
  120.                   BEGIN  (* new line *)
  121.                      OutCount := 1;
  122.                      WriteLn
  123.                   END    (* new line *)
  124.                      ELSE
  125.                         OutCount := OutCount + 1
  126.             END;   (* push a random element on the stack *)
  127.  
  128.          WriteLn;
  129.          WriteLn ('The size of the stack is now ',GetStackSize (TestStack),'.');
  130.          Write ('The item at the top of the stack is: ');
  131.          Peek (TestStack, Ch, Error);
  132.          DisplayData (Ch);
  133.          WriteLn;
  134.  
  135.          WriteLn;
  136.          WriteLn ('Retrieving elements from the stack:');
  137.          WriteLn;
  138.  
  139.          OutCount := 1;
  140.          Pop (TestStack, Ch, Error);
  141.          WHILE NOT Error DO
  142.             BEGIN  (* show stack *)
  143.                DisplayData (Ch);
  144.                IF OutCount = CharsPerLine THEN
  145.                   BEGIN  (* new line *)
  146.                      WriteLn;
  147.                      OutCount := 1
  148.                   END    (* new line *)
  149.                      ELSE
  150.                         OutCount := OutCount + 1;
  151.  
  152.                Pop (TestStack, Ch, Error)
  153.             END;    (* show stack *)
  154.          WriteLn;
  155.          WriteLn ('    --- End Of Stack ---');
  156.          WriteLn
  157.       END;   (* TestNumbers *)
  158.  
  159.    PROCEDURE TestRobustness;
  160.  
  161.       VAR TestStack: StackType;
  162.           Ch: StackDataType;
  163.           Error: Boolean;
  164.           I: Integer;  (* NOTE: the type of this variable must be changed *)
  165.                        (*       if the type StackIndexType is changed.    *)
  166.  
  167.  
  168.       BEGIN  (* TestRobustness *)
  169.          WriteLn;
  170.          WriteLn ('    --- Starting Robustness Test ---');
  171.          WriteLn;
  172.          InitStack (TestStack);
  173.  
  174.          Write ('Peeking into an empty stack: ');
  175.          Peek (TestStack, Ch, Error);
  176.          WriteLn ('Error = ', Error);
  177.  
  178.          Write ('Reading from an empty stack: ');
  179.          Pop (TestStack, Ch, Error);
  180.          WriteLn ('Error = ',Error);
  181.  
  182.          Write ('Pushing an element onto the stack: ');
  183.          RandomStackData (Ch);
  184.          Push (TestStack, Ch, Error);
  185.          WriteLn ('Error = ',Error);
  186.  
  187.          Write ('Peeking onto a good stack: ');
  188.          Peek (TestStack, Ch, Error);
  189.          WriteLn ('Error = ',Error);
  190.  
  191.          Write ('Retrieving an element from a good stack: ');
  192.          Pop (TestStack, Ch, Error);
  193.          WriteLn ('Error = ',Error);
  194.  
  195.          FOR I := 1 TO MaxStackSize DO
  196.             BEGIN  (* push a random element *)
  197.                RandomStackData (Ch);
  198.                Push (TestStack,Ch,Error)
  199.             END;   (* push a random element *)
  200.  
  201.          Write ('Trying to overflow the stack: ');
  202.          Push (TestStack,Ch,Error);
  203.          WriteLn ('Error = ',Error);
  204.  
  205.          Write ('Peeking onto a full stack: ');
  206.          Peek (TestStack, Ch, Error);
  207.          WriteLn ('Error = ',Error);
  208.  
  209.          Write ('Retrieving an element from a full stack: ');
  210.          Pop (TestStack, Ch, Error);
  211.          WriteLn ('Error = ',Error);
  212.  
  213.          WriteLn;
  214.          WriteLn ('    --- End of Robustness Test');
  215.          WriteLn
  216.       END;   (* TestRobustness *)
  217.  
  218.    PROCEDURE SayGoodBye;
  219.  
  220.       BEGIN  (* SayGoodBye *)
  221.          WriteLn;
  222.          WriteLn ('             *** END OF PROGRAM ***');
  223.          WriteLn
  224.       END;   (* SayGoodBye *)
  225.  
  226.    BEGIN  (* TestStackArray *)
  227.       GreetTheUser;
  228.       TestHello;
  229.       TestNumbers;
  230.       TestRobustness;
  231.       SayGoodBye
  232.    END.   (* TestStackArray *)
  233.